"""
语音命令处理工具
用于解析和执行用户语音命令
"""

from typing import Dict, Any, List, Optional
from langchain.tools import BaseTool
import logging
import re

logger = logging.getLogger(__name__)

class VoiceCommandProcessorTool(BaseTool):
    """语音命令处理器工具"""
    
    name: str = "voice_command_processor"
    description: str = """
    处理用户语音命令，将其解析为可执行的操作。
    支持的命令包括：
    - 搜索查询
    - 创建/删除项目
    - 获取帮助信息
    - 系统状态查询
    """
    
    def _run(self, command_text: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """
        处理语音命令
        
        Args:
            command_text: 语音识别后的文本
            context: 上下文信息
            
        Returns:
            包含命令意图、参数和执行结果的字典
        """
        try:
            # 解析命令意图
            intent_info = self._parse_command_intent(command_text)
            
            # 执行命令
            execution_result = self._execute_command(intent_info, context)
            
            return {
                "command_text": command_text,
                "intent": intent_info,
                "result": execution_result,
                "success": True
            }
        except Exception as e:
            logger.error(f"处理语音命令时出错: {str(e)}")
            return {
                "command_text": command_text,
                "intent": {},
                "result": f"处理命令时出错: {str(e)}",
                "success": False
            }
    
    async def _arun(self, command_text: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """异步处理语音命令"""
        return self._run(command_text, context)
    
    def _parse_command_intent(self, command_text: str) -> Dict[str, Any]:
        """
        解析命令意图
        
        Args:
            command_text: 命令文本
            
        Returns:
            包含意图和参数的字典
        """
        intent_info = {
            "type": "unknown",
            "parameters": {},
            "confidence": 0.0
        }
        
        # 定义命令模式
        command_patterns = {
            "search": [
                r"(搜索|查找|查询)\s*(.+)",
                r"我想\s*(搜索|查找|查询)\s*(.+)",
                r"请\s*(搜索|查找|查询)\s*(.+)"
            ],
            "create": [
                r"(创建|新建|增加)\s*(.+)",
                r"我想\s*(创建|新建|增加)\s*(.+)",
                r"请\s*(创建|新建|增加)\s*(.+)"
            ],
            "delete": [
                r"(删除|移除)\s*(.+)",
                r"我想\s*(删除|移除)\s*(.+)",
                r"请\s*(删除|移除)\s*(.+)"
            ],
            "help": [
                r"(帮助|怎么)\s*(.+)",
                r"如何\s*(.+)",
                r"怎么\s*(.+)"
            ],
            "status": [
                r"(状态|情况)\s*(.+)",
                r"系统\s*(状态|情况)\s*(.+)"
            ]
        }
        
        command_text_lower = command_text.lower()
        
        # 匹配命令模式
        for intent_type, patterns in command_patterns.items():
            for pattern in patterns:
                match = re.search(pattern, command_text, re.IGNORECASE)
                if match:
                    intent_info["type"] = intent_type
                    if len(match.groups()) > 1:
                        intent_info["parameters"]["query"] = match.group(2)
                    else:
                        intent_info["parameters"]["query"] = command_text
                    intent_info["confidence"] = 0.9
                    return intent_info
        
        # 如果没有匹配到特定命令，返回原始文本作为查询
        intent_info["type"] = "search"
        intent_info["parameters"]["query"] = command_text
        intent_info["confidence"] = 0.5
        
        return intent_info
    
    def _execute_command(self, intent_info: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> str:
        """
        执行命令
        
        Args:
            intent_info: 意图信息
            context: 上下文信息
            
        Returns:
            执行结果
        """
        intent_type = intent_info.get("type", "unknown")
        parameters = intent_info.get("parameters", {})
        query = parameters.get("query", "")
        
        # 根据意图类型执行相应操作
        if intent_type == "search":
            return f"正在为您搜索关于'{query}'的信息..."
            
        elif intent_type == "create":
            return f"正在为您创建'{query}'..."
            
        elif intent_type == "delete":
            return f"正在为您删除'{query}'..."
            
        elif intent_type == "help":
            return self._get_help_response(query)
            
        elif intent_type == "status":
            return "系统运行正常，所有服务均可用。"
            
        else:
            return f"已接收到您的命令: {query}"

    def _get_help_response(self, query: str) -> str:
        """
        获取帮助响应
        
        Args:
            query: 查询内容
            
        Returns:
            帮助信息
        """
        help_texts = {
            "搜索": "您可以对我说'搜索[内容]'来查找信息",
            "创建": "您可以对我说'创建[项目名称]'来创建新项目",
            "删除": "您可以对我说'删除[项目名称]'来删除项目",
            "状态": "您可以对我说'系统状态'来查看系统状态"
        }
        
        for keyword, help_text in help_texts.items():
            if keyword in query:
                return help_text
                
        return "我可以帮您执行搜索、创建、删除等操作。请告诉我您需要什么帮助？"

def get_voice_command_processor() -> VoiceCommandProcessorTool:
    """获取语音命令处理器实例"""
    return VoiceCommandProcessorTool()